#!/usr/bin/env node

/**
 * 多平台构建脚本
 * 用于自动化构建和打包应用到不同平台
 */

const { execSync } = require('child_process')
const fs = require('fs')
const path = require('path')

// 构建配置
const BUILD_CONFIG = {
  // 支持的平台
  platforms: {
    'macos': {
      target: 'universal-apple-darwin',
      extension: '.app',
      description: 'macOS 通用应用'
    },
    'windows': {
      target: 'x86_64-pc-windows-msvc',
      extension: '.exe',
      description: 'Windows 64位应用'
    },
    'linux': {
      target: 'x86_64-unknown-linux-gnu',
      extension: '.AppImage',
      description: 'Linux AppImage'
    }
  },
  
  // 输出目录
  outputDir: 'dist-tauri',
  
  // 版本信息
  version: '1.0.0',
  
  // 构建选项
  options: {
    release: true,
    verbose: true,
    cleanup: true
  }
}

class BuildManager {
  constructor() {
    this.startTime = Date.now()
    this.buildResults = []
  }

  /**
   * 执行命令并输出结果
   */
  execCommand(command, description) {
    console.log(`\n🔨 ${description}`)
    console.log(`📝 执行命令: ${command}`)
    
    try {
      const output = execSync(command, { 
        stdio: 'inherit',
        encoding: 'utf8',
        cwd: process.cwd()
      })
      
      console.log(`✅ ${description} - 完成`)
      return { success: true, output }
    } catch (error) {
      console.error(`❌ ${description} - 失败`)
      console.error(`错误信息: ${error.message}`)
      return { success: false, error: error.message }
    }
  }

  /**
   * 检查构建环境
   */
  checkEnvironment() {
    console.log('🔍 检查构建环境...')
    
    // 检查 Node.js
    const nodeVersion = process.version
    console.log(`📦 Node.js 版本: ${nodeVersion}`)
    
    // 检查 npm
    try {
      const npmVersion = execSync('npm --version', { encoding: 'utf8' }).trim()
      console.log(`📦 npm 版本: ${npmVersion}`)
    } catch (error) {
      console.error('❌ npm 未安装或不可用')
      process.exit(1)
    }
    
    // 检查 Rust
    try {
      const rustVersion = execSync('rustc --version', { encoding: 'utf8' }).trim()
      console.log(`🦀 Rust 版本: ${rustVersion}`)
    } catch (error) {
      console.error('❌ Rust 未安装或不可用')
      console.error('请安装 Rust: https://rustup.rs/')
      process.exit(1)
    }
    
    // 检查 Tauri CLI
    try {
      const tauriVersion = execSync('cargo tauri --version', { encoding: 'utf8' }).trim()
      console.log(`🚀 Tauri CLI 版本: ${tauriVersion}`)
    } catch (error) {
      console.error('❌ Tauri CLI 未安装')
      console.error('请安装 Tauri CLI: cargo install tauri-cli')
      process.exit(1)
    }
    
    console.log('✅ 构建环境检查完成')
  }

  /**
   * 清理旧的构建文件
   */
  cleanup() {
    if (!BUILD_CONFIG.options.cleanup) return
    
    console.log('🧹 清理旧的构建文件...')
    
    const dirsToClean = [
      'dist',
      'src-tauri/target',
      BUILD_CONFIG.outputDir
    ]
    
    dirsToClean.forEach(dir => {
      if (fs.existsSync(dir)) {
        console.log(`🗑️  删除目录: ${dir}`)
        fs.rmSync(dir, { recursive: true, force: true })
      }
    })
    
    console.log('✅ 清理完成')
  }

  /**
   * 安装依赖
   */
  installDependencies() {
    console.log('📦 安装依赖...')
    
    // 安装前端依赖
    const frontendResult = this.execCommand('npm install', '安装前端依赖')
    if (!frontendResult.success) {
      console.error('❌ 前端依赖安装失败')
      process.exit(1)
    }
    
    // 安装 Rust 依赖
    const rustResult = this.execCommand('cargo fetch --manifest-path src-tauri/Cargo.toml', '获取 Rust 依赖')
    if (!rustResult.success) {
      console.warn('⚠️  Rust 依赖获取失败，将在构建时自动处理')
    }
    
    console.log('✅ 依赖安装完成')
  }

  /**
   * 构建前端资源
   */
  buildFrontend() {
    console.log('🏗️  构建前端资源...')
    
    const result = this.execCommand('npm run build', '构建前端应用')
    if (!result.success) {
      console.error('❌ 前端构建失败')
      process.exit(1)
    }
    
    // 检查构建输出
    if (!fs.existsSync('dist')) {
      console.error('❌ 前端构建输出目录不存在')
      process.exit(1)
    }
    
    console.log('✅ 前端构建完成')
  }

  /**
   * 构建指定平台
   */
  buildPlatform(platform) {
    const config = BUILD_CONFIG.platforms[platform]
    if (!config) {
      console.error(`❌ 不支持的平台: ${platform}`)
      return { success: false, error: `不支持的平台: ${platform}` }
    }
    
    console.log(`\n🚀 开始构建 ${config.description}`)
    
    // 构建命令
    let command = 'cargo tauri build'
    
    if (BUILD_CONFIG.options.release) {
      command += ' --release'
    }
    
    if (BUILD_CONFIG.options.verbose) {
      command += ' --verbose'
    }
    
    // 添加目标平台（如果需要）
    if (config.target && config.target !== 'native') {
      command += ` --target ${config.target}`
    }
    
    const result = this.execCommand(command, `构建 ${config.description}`)
    
    if (result.success) {
      this.buildResults.push({
        platform,
        success: true,
        description: config.description,
        timestamp: new Date().toISOString()
      })
    } else {
      this.buildResults.push({
        platform,
        success: false,
        description: config.description,
        error: result.error,
        timestamp: new Date().toISOString()
      })
    }
    
    return result
  }

  /**
   * 构建所有平台
   */
  buildAllPlatforms() {
    console.log('🌍 开始多平台构建...')
    
    const platforms = Object.keys(BUILD_CONFIG.platforms)
    let successCount = 0
    
    for (const platform of platforms) {
      const result = this.buildPlatform(platform)
      if (result.success) {
        successCount++
      }
    }
    
    console.log(`\n📊 构建结果: ${successCount}/${platforms.length} 个平台构建成功`)
    
    return successCount === platforms.length
  }

  /**
   * 生成构建报告
   */
  generateReport() {
    const endTime = Date.now()
    const duration = Math.round((endTime - this.startTime) / 1000)
    
    console.log('\n📋 构建报告')
    console.log('=' .repeat(50))
    console.log(`🕐 总耗时: ${duration} 秒`)
    console.log(`📅 构建时间: ${new Date().toLocaleString()}`)
    console.log(`📦 应用版本: ${BUILD_CONFIG.version}`)
    
    console.log('\n🎯 构建结果:')
    this.buildResults.forEach(result => {
      const status = result.success ? '✅' : '❌'
      console.log(`  ${status} ${result.description}`)
      if (!result.success && result.error) {
        console.log(`     错误: ${result.error}`)
      }
    })
    
    // 输出文件位置
    if (fs.existsSync(BUILD_CONFIG.outputDir)) {
      console.log('\n📁 输出文件:')
      const files = fs.readdirSync(BUILD_CONFIG.outputDir, { recursive: true })
      files.forEach(file => {
        const filePath = path.join(BUILD_CONFIG.outputDir, file)
        if (fs.statSync(filePath).isFile()) {
          const size = fs.statSync(filePath).size
          const sizeStr = this.formatFileSize(size)
          console.log(`  📄 ${file} (${sizeStr})`)
        }
      })
    }
    
    console.log('=' .repeat(50))
  }

  /**
   * 格式化文件大小
   */
  formatFileSize(bytes) {
    const units = ['B', 'KB', 'MB', 'GB']
    let size = bytes
    let unitIndex = 0
    
    while (size >= 1024 && unitIndex < units.length - 1) {
      size /= 1024
      unitIndex++
    }
    
    return `${size.toFixed(1)} ${units[unitIndex]}`
  }

  /**
   * 主构建流程
   */
  async build(targetPlatform = null) {
    console.log('🚀 YunPo Markdown Editor 构建工具')
    console.log('=' .repeat(50))
    
    try {
      // 1. 检查环境
      this.checkEnvironment()
      
      // 2. 清理旧文件
      this.cleanup()
      
      // 3. 安装依赖
      this.installDependencies()
      
      // 4. 构建前端
      this.buildFrontend()
      
      // 5. 构建应用
      if (targetPlatform) {
        console.log(`🎯 构建目标平台: ${targetPlatform}`)
        this.buildPlatform(targetPlatform)
      } else {
        this.buildAllPlatforms()
      }
      
      // 6. 生成报告
      this.generateReport()
      
      console.log('\n🎉 构建完成!')
      
    } catch (error) {
      console.error('\n💥 构建失败!')
      console.error(`错误信息: ${error.message}`)
      process.exit(1)
    }
  }
}

// 命令行参数处理
function parseArguments() {
  const args = process.argv.slice(2)
  const options = {
    platform: null,
    help: false
  }
  
  for (let i = 0; i < args.length; i++) {
    const arg = args[i]
    
    if (arg === '--help' || arg === '-h') {
      options.help = true
    } else if (arg === '--platform' || arg === '-p') {
      options.platform = args[i + 1]
      i++
    } else if (arg.startsWith('--platform=')) {
      options.platform = arg.split('=')[1]
    }
  }
  
  return options
}

// 显示帮助信息
function showHelp() {
  console.log('YunPo Markdown Editor 构建工具')
  console.log('')
  console.log('用法:')
  console.log('  node scripts/build.js [选项]')
  console.log('')
  console.log('选项:')
  console.log('  -p, --platform <平台>  构建指定平台 (macos, windows, linux)')
  console.log('  -h, --help             显示帮助信息')
  console.log('')
  console.log('示例:')
  console.log('  node scripts/build.js                    # 构建所有平台')
  console.log('  node scripts/build.js --platform macos   # 只构建 macOS')
  console.log('  node scripts/build.js --platform windows # 只构建 Windows')
  console.log('')
  console.log('支持的平台:')
  Object.entries(BUILD_CONFIG.platforms).forEach(([key, config]) => {
    console.log(`  ${key.padEnd(8)} - ${config.description}`)
  })
}

// 主程序入口
async function main() {
  const options = parseArguments()
  
  if (options.help) {
    showHelp()
    return
  }
  
  // 验证平台参数
  if (options.platform && !BUILD_CONFIG.platforms[options.platform]) {
    console.error(`❌ 不支持的平台: ${options.platform}`)
    console.error('支持的平台:', Object.keys(BUILD_CONFIG.platforms).join(', '))
    process.exit(1)
  }
  
  const builder = new BuildManager()
  await builder.build(options.platform)
}

// 运行主程序
if (require.main === module) {
  main().catch(error => {
    console.error('💥 构建脚本执行失败:', error)
    process.exit(1)
  })
}

module.exports = { BuildManager, BUILD_CONFIG }